/********************************
 * ETK - Easy ToolKit
 * Copyright (C) 2007-2008 Ekinoks (scv.ekinoks@gmail.com)
 * All rights reserved.
 *
 *    This file is part of ETK.
 *
 *    Foobar is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    Foobar is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with Foobar; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 ***********************************************************************************/

#ifndef __ETK_TOOLKIT_H__
#define __ETK_TOOLKIT_H__
#include <iostream>

#include "../../define.h"
#include "../../RWidget.h"


namespace etk
{
    class Widget;
    class CallBack;
    class RWidget;


    class EventButton;
    class EventButtonImpl;

    class EventScroll;
    class EventScrollImpl;

    class EventKey;
    class EventKeyImpl;

    class EventMotion;
    class EventMotionImpl;

    class State;

    class ShutterButtonModel;
    class ShutterScrollModel;
    class ShutterKeyModel;



    /// Fonction graphique de bas niveau.
    class ToolKit
    {
        public :
            /** Inisalisation de la ToolKit */
            virtual void init(int argc, char *argv[]) const = 0;

            /** Depart de la boucle d'évenements */
            virtual void go() const = 0;

            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// LES WIDGET //////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            /** rendre le widget visible
            * @param rWidget : RWidget a rendre visible
            */
            virtual void widget_show(const RWidget* rWidget) const = 0;

            /** rendre le widget invisible
            * @param rWidget : RWidget a rendre invisible
            */
            virtual void widget_hide(const RWidget* rWidget) const = 0;

            /** Suprimer un widget
            *   @param rWidget : RWidget conserné
            */
            virtual void widget_destroy(const RWidget* rWidget) const = 0;

            // FIN WIDGET /////////////////////////////////////////////////////////////////////////////////////


            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// LES SIGNAUX /////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            /** Signaler que les "essential event" sont suseptible d'étre connecté (button, key, focus, scroll)
            *   @param rWidget : RWidget conserné
            */
            virtual void add_essential_event(const RWidget* rWidget) const = 0;

            /** connecter un signal
            *   @param widget   : Widget sur le quel l'evenement doit étre scruté
            *   @param event    : Numero de l'evenement a scruter
            *   @param callBack : CallBack a donner en argument de la fonction CallBack::call
            *   @return l'id du signal créé
            */
            virtual long signal_connect(const RWidget* rWidget, const int event, CallBack * callBack) const = 0;

            /** connecter un signal
            *   @param widget   : Widget sur le quel l'evenement doit étre scruté
            *   @param event    : Numero de l'evenement a scruter
            *   @param f        : Fonction a appeller lorsque l'evenement intervien
            *   @param arg      : Argument a passer en paramétre a la fonction f
            *   @return l'id du signal créé
            */
            virtual long signal_connect(const RWidget* rWidget, const int event, int(*f)(PWIDGET widget, int event, void* arg), void* arg=NULL) const = 0;

            /** connecter un signal qui aura lieu apres supretion de l'objet
            *   @param widget   : Widget sur le quel l'evenement doit étre scruté
            *   @param event    : Numero de l'evenement a scruter
            *   @param callBack : CallBack a donner en argument de la fonction CallBack::call
            *   @return l'id du signal créé
            */
            virtual long signal_connect_after(const RWidget* rWidget, const int event, CallBack * callBack) const = 0;

            /** connecter un signal qui aura lieu apres supretion de l'objet
            *   @param widget   : Widget sur le quel l'evenement doit étre scruté
            *   @param event    : Numero de l'evenement a scruter
            *   @param f        : Fonction a appeller lorsque l'evenement intervien
            *   @param arg      : Argument a passer en paramétre a la fonction f
            *   @return l'id du signal créé
            */
            virtual long signal_connect_after(const RWidget* rWidget, const int event, int(*f)(PWIDGET widget, int event, void* arg), void* arg=NULL) const = 0;

            /** déconnecter un signal
            *   @param rWidget      : RWidget conserné
            *   @param id_signal    : Id conserné
            */
            virtual void signal_disconnect(const RWidget* rWidget, const long id_signal) const = 0;

            /** savoir si le signal est connecté
            *   @param rWidget      : RWidget conserné
            *   @param id_signal    : id conserné
            *   @return si le signal est connecté
            */
            virtual bool signal_is_connected(const RWidget* rWidget, const long id_signal) const = 0;

            virtual void signal_block(const RWidget* rWidget, const long id_signal) const = 0;

            virtual void signal_unblock(const RWidget* rWidget, const long id_signal) const = 0;

            // FIN SIGNAUX /////////////////////////////////////////////////////////////////////////////////////


            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// LES NEW /////////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            /** créer une fenetre
            *   @return le RWidget de la fenetre créé
            */
            virtual RWidget* window_new() const = 0;

            /** créer une box
            *   @param vertical     : true pour vertical et false pour horizontal
            *   @param homogeneous  : homogeneous
            *   @param spacing      : spacing
            */
            virtual RWidget* box_new(const position_e position, const bool homogeneous, const int spacing) const = 0;

            virtual RWidget* button_new_with_label(const char* label) = 0;

            // FIN MUTATIONS //////////////////////////////////////////////////////////////////////////////////

            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// WINDOW //////////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            /** Changer le titre de la fenetre
            *   @param rWidget  : RWidget de la Window conserné
            *   @param title    : Nouveau titre
            */
            virtual void window_set_title(const RWidget* rWidget, const /*char**/std::string title) const = 0;

            /** Changer la taille de la fenetre
            *   @param rWidget : RWidget de la Window conserné
            *   @param size_x : Nouvelle taille X (en pixel)
            *   @param size_y : Nouvelle taille Y (en pixel)
            */
            virtual void window_set_size(const RWidget* rWidget, const int size_x, const int size_y) const = 0;

            /** Changer la possition de la fenetre
            *   @param rWidget  : RWidget de la Window conserné
            *   @param x        : Nouvelle position X de l'ange superieur gauche (en pixel)
            *   @param y        : Nouvelle position Y de l'ange superieur gauche (en pixel)
            */
            virtual void window_set_position(const RWidget* rWidget, const int x, const int y) const = 0;

            // FIN WINDOW //////////////////////////////////////////////////////////////////////////////////////


            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// CONTAINER ///////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            /** Ajouter le widget dans le container
            *   @param container    : container conserné
            *   @param widget       : widget a ajouter au container
            */
            virtual void container_add(const RWidget* container, const RWidget* widget) const = 0;

            /** Retirer le widget dans le container
            *   @param container    : container conserné
            *   @param widget       : widget a retirer au container
            */
            virtual void container_remove(const RWidget* container, const RWidget* widget) const = 0;

            // FIN CONTAINER //////////////////////////////////////////////////////////////////////////////////////


            // //////////////////////////////////////////////////////////////////////////////////////////////////
            // /////////////////////////////// EVENT ///////////////////////////////////////////////////////////
            // ////////////////////////////////////////////////////////////////////////////////////////////////

            virtual void updateEvent(EventButton &e, void* realEvent) const = 0;
            virtual void updateEvent(EventScroll &e, void* realEvent) const = 0;
            virtual void updateEvent(EventKey &e, void* realEvent) const = 0;
            virtual void updateEvent(EventMotion &e, void* realEvent) const = 0;




            // FIN EVENT //////////////////////////////////////////////////////////////////////////////////////


        protected :
            void* getPWIDGET(const RWidget *rWidget) const;

            template <class EImpl, class E>
            EImpl& getImpl(E& e) const
            {
                return e.pimpl_;
            }

            void setState(State &state, long int li) const;

            void setButton(ShutterButtonModel &s, int button) const;

            void setEventType(ShutterButtonModel &s, int eventType) const;

            void setDirection(ShutterScrollModel &s, int direction) const;

            void setKeyCode(ShutterKeyModel &s, int keycode) const;

            void setCharacter(ShutterKeyModel &s, char* string) const;

    };
}





#endif /* #ifndef __ETK_TOOLKIT_H__ */



